home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / Source / Halma 1.1.source Folder / Halma ƒ / Shell ƒ / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-25  |  11.3 KB  |  468 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "menus.h"
  26. #include "help.h"
  27. #include "environment.h"
  28. #include "sounds.h"
  29. #include "error.h"
  30. #include "launch.h"
  31. #include "file interface.h"
  32. #include "halma load-save.h"
  33. #include "halma.h"
  34. #include "debinhex dispatch.h"
  35. #include "file management.h"
  36. #include "program globals.h"
  37. #include "halma snow.h"
  38.  
  39. extern    long        menuDisable : 0x0b54;
  40.  
  41. Boolean            gMenuEnabled;
  42. MenuHandle        gAppleMenu;
  43. MenuHandle        gFileMenu;
  44. MenuHandle        gEditMenu;
  45. MenuHandle        gOptionsMenu;
  46. MenuHandle        gSnowMenu;
  47.  
  48. enum
  49. {
  50.     helpMenu = 200,
  51.     
  52.     appleMenu = 400, fileMenu, editMenu, optionsMenu, snowMenuColor, snowMenuBW,
  53.     
  54.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  55.     
  56.     newItem = 1, openItem, closeItem, saveItem, saveAsItem, deBinHexItem = 7,
  57.         launchItem=9, forceQuitItem = 11, quitItem,
  58.     
  59.     undoItem = 1, cutItem = 3, copyItem, pasteItem, clearItem,
  60.     
  61.     boardItem = 1, soundToggle = 3, hideItem = 5,
  62.     
  63.     slowItem=1, mediumItem, fastItem, unused1, redItem, greenItem, blueItem, cyanItem,
  64.         magentaItem, yellowItem, whiteItem, unused2, mutateItem
  65. };
  66.  
  67. /*-----------------------------------------------------------------------------------*/
  68. /* internal stuff for menus.c                                                        */
  69.  
  70. void HandleAppleMenu(short menuItem);
  71. void HandleFileMenu(short menuItem);
  72. void HandleEditMenu(short menuItem);
  73. void HandleHelpMenu(void);
  74. void HandleOptionsMenu(short menuItem);
  75. void HandleSnowMenu(short menuItem);
  76.  
  77. Boolean InitTheMenus(void)
  78. {
  79.     Handle        MBARHandle;
  80.     
  81.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  82.         return FALSE;
  83.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  84.     
  85.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  86.         return FALSE;
  87.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  88.         return FALSE;
  89.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  90.         return FALSE;
  91.     if ((gOptionsMenu=GetMHandle(optionsMenu))==0L)
  92.         return FALSE;
  93.     if (gHasColorQD)
  94.     {
  95.         if ((gSnowMenu=GetMenu(snowMenuColor))==0L)
  96.             return FALSE;
  97.     }
  98.     else
  99.     {
  100.         if ((gSnowMenu=GetMenu(snowMenuBW))==0L)
  101.             return FALSE;
  102.     }
  103.     
  104.     InsertMenu(gSnowMenu, 0);
  105.     
  106.     if (gSystemSevenOrLater)
  107.     {
  108.         AppendMenu(gOptionsMenu, "\p-");
  109.         AppendMenu(gOptionsMenu, "\pHide/1");
  110.     }
  111.     
  112.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  113.     
  114.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  115.     DrawMenuBar();                                /* draws the actual menu bar */
  116.     
  117.     return TRUE;
  118. }
  119.  
  120. void AdjustMenus(void)
  121. {
  122.     WindowPeek    theWindow;
  123.     short            kind;
  124.     
  125.     if (gInProgress)
  126.     {
  127.         DisableItem(gAppleMenu, aboutItem);
  128.         DisableItem(gAppleMenu, aboutMSGItem);
  129.         DisableItem(gAppleMenu, helpPointerItem);
  130.         if (gSystemSevenOrLater)
  131.         {
  132.             DisableItem(gFileMenu, newItem);
  133.             DisableItem(gFileMenu, openItem);
  134.             DisableItem(gFileMenu, closeItem);
  135.             DisableItem(gFileMenu, deBinHexItem);
  136.             DisableItem(gFileMenu, launchItem);
  137.             DisableItem(gFileMenu, quitItem);
  138.         }
  139.         else DisableItem(gFileMenu, 0);
  140.         
  141.         DisableItem(gEditMenu, 0);
  142.         DisableItem(gOptionsMenu, 0);
  143.         DisableItem(gSnowMenu, 0);
  144.     }
  145.     else
  146.     {
  147.         EnableItem(gAppleMenu, aboutItem);
  148.         EnableItem(gAppleMenu, aboutMSGItem);
  149.         EnableItem(gAppleMenu, helpPointerItem);
  150.         if (gSystemSevenOrLater)
  151.         {
  152.             EnableItem(gFileMenu, newItem);
  153.             EnableItem(gFileMenu, openItem);
  154.             EnableItem(gFileMenu, closeItem);
  155.             EnableItem(gFileMenu, deBinHexItem);
  156.             EnableItem(gFileMenu, launchItem);
  157.             EnableItem(gFileMenu, quitItem);
  158.         }
  159.         else EnableItem(gFileMenu, 0);
  160.         EnableItem(gEditMenu, 0);
  161.         EnableItem(gOptionsMenu, 0);
  162.         EnableItem(gSnowMenu, 0);
  163.         
  164.         theWindow = (WindowPeek)FrontWindow();
  165.         kind = theWindow ? theWindow->windowKind : 0;
  166.         
  167.         if (kind < 0)
  168.         {
  169.             EnableItem(gEditMenu, undoItem);
  170.             EnableItem(gEditMenu, cutItem);
  171.             EnableItem(gEditMenu, copyItem);
  172.             EnableItem(gEditMenu, pasteItem);
  173.             EnableItem(gEditMenu, clearItem);
  174.         }
  175.         else
  176.         {
  177.             if ((theWindow!=0L) && ((WindowPtr)theWindow==gTheWindow[kMainWindow]) &&
  178.                 ((gNumMoves>0) || (gThisJumpString[0]>0x00)))
  179.                 EnableItem(gEditMenu, undoItem);
  180.             else
  181.                 DisableItem(gEditMenu, undoItem);
  182.             DisableItem(gEditMenu, cutItem);
  183.             DisableItem(gEditMenu, copyItem);
  184.             DisableItem(gEditMenu, pasteItem);
  185.             DisableItem(gEditMenu, clearItem);
  186.         }
  187.         
  188.         if(theWindow)
  189.             EnableItem(gFileMenu, closeItem);
  190.         else
  191.             DisableItem(gFileMenu, closeItem);
  192.         
  193.         if (gTheWindow[kMainWindow])
  194.         {
  195.             DisableItem(gFileMenu, newItem);
  196.             DisableItem(gFileMenu, openItem);
  197.             DisableItem(gOptionsMenu, boardItem);
  198.             EnableItem(gFileMenu, saveItem);
  199.             EnableItem(gFileMenu, saveAsItem);
  200.         }
  201.         else
  202.         {
  203.             EnableItem(gFileMenu, newItem);
  204.             EnableItem(gFileMenu, openItem);
  205.             EnableItem(gOptionsMenu, boardItem);
  206.             DisableItem(gFileMenu, saveItem);
  207.             DisableItem(gFileMenu, saveAsItem);
  208.         }
  209.         
  210.         if (gSystemSevenOrLater)
  211.             EnableItem(gFileMenu, forceQuitItem);
  212.         else
  213.             DisableItem(gFileMenu, forceQuitItem);
  214.         
  215.         if (gSoundAvailable)
  216.             EnableItem(gOptionsMenu, soundToggle);
  217.         else
  218.             DisableItem(gOptionsMenu, soundToggle);
  219.     }
  220.     CheckItem(gOptionsMenu, soundToggle, gSoundToggle&&gSoundAvailable);
  221.     CheckItem(gSnowMenu, slowItem, gSnowSpeed==0x01);
  222.     CheckItem(gSnowMenu, mediumItem, gSnowSpeed==0x02);
  223.     CheckItem(gSnowMenu, fastItem, gSnowSpeed==0x03);
  224.     CheckItem(gSnowMenu, redItem, gSnowColor==0x01);
  225.     CheckItem(gSnowMenu, greenItem, gSnowColor==0x02);
  226.     CheckItem(gSnowMenu, blueItem, gSnowColor==0x03);
  227.     CheckItem(gSnowMenu, cyanItem, gSnowColor==0x04);
  228.     CheckItem(gSnowMenu, magentaItem, gSnowColor==0x05);
  229.     CheckItem(gSnowMenu, yellowItem, gSnowColor==0x06);
  230.     CheckItem(gSnowMenu, whiteItem, gSnowColor==0x07);
  231.     CheckItem(gSnowMenu, mutateItem, gSnowMutates);
  232. }
  233.  
  234. void HandleMenu(long mSelect)
  235. {
  236.     short            menuID = HiWord(mSelect);
  237.     short            menuItem = LoWord(mSelect);
  238.     
  239.     if (menuID==0)
  240.     {
  241.         menuID=HiWord(menuDisable);
  242.         menuItem=LoWord(menuDisable);
  243.         gMenuEnabled=FALSE;
  244.     }
  245.     else gMenuEnabled=TRUE;
  246.     menuDisable=0L;
  247.  
  248.     switch (menuID)
  249.     {
  250.         case appleMenu:
  251.             HandleAppleMenu(menuItem);
  252.             break;
  253.         case fileMenu:
  254.             HandleFileMenu(menuItem);
  255.             break;    
  256.         case editMenu:
  257.             HandleEditMenu(menuItem);
  258.             break;
  259.         case optionsMenu:
  260.             HandleOptionsMenu(menuItem);
  261.             break;
  262.         case snowMenuColor:
  263.         case snowMenuBW:
  264.             HandleSnowMenu(menuItem);
  265.             break;
  266.     }
  267. }
  268.  
  269. void DoTheCloseThing(WindowPeek theWindow)
  270. /* a standard close procedure, called when "close" is chosen from File menu and when
  271.    a window is closed through its close box */
  272. {
  273.     Boolean            gotone;
  274.     short            i;
  275.     short            kind;
  276.     
  277.     if (theWindow==0L)
  278.         return;
  279.     
  280.     kind = theWindow ? theWindow->windowKind : 0;
  281.     if (kind<0)        /* DA window or other system window */
  282.         CloseDeskAcc(kind);
  283.     else
  284.     {
  285.         gotone=FALSE;
  286.         /* see if it's one of ours */
  287.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  288.             gotone=((WindowPtr)theWindow==gTheWindow[i]);
  289.         
  290.         if (gotone)        /* if it's one of ours...  see graphics.c */
  291.             CloseTheWindow(gTheWindowData[i-1]);    /* this may return FALSE = not closed */
  292.         else
  293.             DisposeWindow((WindowPtr)theWindow);        /* not one of ours, so just close it */
  294.     
  295.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  296.     }
  297. }
  298.  
  299. void HandleAppleMenu(short menuItem)
  300. {
  301.     GrafPtr        savePort;
  302.     Str255        name;
  303.     
  304.     switch (menuItem)
  305.     {
  306.         case aboutItem:
  307.             if (gMenuEnabled)
  308.                 OpenTheWindow(kAbout);
  309.             else DoSound(sound_fluff, TRUE);
  310.             break;
  311.         case aboutMSGItem:
  312.             if (gMenuEnabled)
  313.                 OpenTheWindow(kAboutMSG);
  314.             else DoSound(sound_fluff, TRUE);
  315.             break;
  316.         case helpPointerItem:
  317.             if (gMenuEnabled)
  318.                 HandleHelpMenu();
  319.             else DoSound(sound_fluff, TRUE);
  320.             break;
  321.         default:
  322.             if (menuItem > helpPointerItem+1)
  323.             {
  324.                 GetPort(&savePort);
  325.                 GetItem(gAppleMenu, menuItem, name);
  326.                 OpenDeskAcc(name);
  327.                 SetPort(savePort);
  328.             }
  329.             break;
  330.     }
  331. }
  332.  
  333. void HandleFileMenu(short menuItem)
  334. {
  335.     WindowPtr            theWindow;
  336.     short                i;
  337.     Boolean                gotone;
  338.     
  339.     switch (menuItem)
  340.     {
  341.         case newItem:
  342.             if (gMenuEnabled)
  343.                 NewGame();
  344.             else DoSound(sound_fluff, TRUE);
  345.             break;
  346.         case openItem:
  347.             if (gMenuEnabled)
  348.                 LoadSaveDispatch(TRUE, FALSE);
  349.             else DoSound(sound_fluff, TRUE);
  350.             break;
  351.         case closeItem:
  352.             if (gMenuEnabled)
  353.                 DoTheCloseThing((WindowPeek)FrontWindow());
  354.             else DoSound(sound_fluff, TRUE);
  355.             break;
  356.         case saveItem:
  357.             if (gMenuEnabled)
  358.                 LoadSaveDispatch(FALSE, TRUE);
  359.             else DoSound(sound_fluff, TRUE);
  360.             break;
  361.         case saveAsItem:
  362.             if (gMenuEnabled)
  363.                 LoadSaveDispatch(FALSE, FALSE);
  364.             else DoSound(sound_fluff, TRUE);
  365.             break;
  366.         case deBinHexItem:
  367.             if (gMenuEnabled)
  368.             {
  369.                 if (GetSourceFile(&inputFS, TRUE, FALSE))
  370.                     HandleError(DeBinHexDispatch(), FALSE);
  371.             }
  372.             else DoSound(sound_fluff, TRUE);
  373.             break;
  374.         case launchItem:
  375.             if (gMenuEnabled)
  376.             {
  377.                 LaunchDispatch();
  378.             }
  379.             else DoSound(sound_fluff, TRUE);
  380.         case forceQuitItem:
  381.             if (gMenuEnabled)
  382.                 SysError(0x4e22);
  383.             else DoSound(sound_fluff, TRUE);
  384.             break;
  385.         case quitItem:
  386.             if (gMenuEnabled)
  387.                 gDone = TRUE;
  388.             else DoSound(sound_fluff, TRUE);
  389.             break;
  390.     }
  391. }
  392.  
  393. void HandleEditMenu(short menuItem)
  394. {
  395.     ExtendedWindowDataHandle    theData;
  396.     
  397.     if ((menuItem>1) && (menuItem!=2))
  398.     {
  399.         if (gMenuEnabled)
  400.             SystemEdit(menuItem - 1);
  401.         else DoSound(sound_fluff, TRUE);
  402.     }
  403.     else if (menuItem==undoItem)
  404.     {
  405.         if (gMenuEnabled)
  406.         {
  407.             if (gFrontWindowIsOurs)
  408.             {
  409.                 theData=(ExtendedWindowDataHandle)GetWRefCon(FrontWindow());
  410.                 ((**theData).dispatchProc)((WindowDataHandle)theData, kUndo, 0L);
  411.             }
  412.         }
  413.         else DoSound(sound_fluff, TRUE);
  414.     }
  415. }
  416.  
  417. void HandleOptionsMenu(short menuItem)
  418. {
  419.     switch (menuItem)
  420.     {
  421.         case boardItem:
  422.             if (gMenuEnabled)
  423.                 OpenTheWindow(kBoardSize);
  424.             else DoSound(sound_fluff, TRUE);
  425.             break;
  426.         case soundToggle:
  427.             if (gMenuEnabled)
  428.             {
  429.                 gSoundToggle=!gSoundToggle;
  430.                 DoSound(sound_on, TRUE);
  431.             }
  432.             break;
  433.         case hideItem:
  434.             if (gMenuEnabled)
  435.             {
  436.                 MenuKey(0);
  437.             }
  438.             else DoSound(sound_fluff, TRUE);
  439.             break;
  440.     }
  441. }
  442.  
  443. void HandleSnowMenu(short menuItem)
  444. {
  445.     WindowDataHandle    theData;
  446.     
  447.     theData=gTheWindowData[kMainWindow];
  448.     switch (menuItem)
  449.     {
  450.         case slowItem:        gSnowSpeed=0x01;    GetRidOfSnowflake(theData);    break;
  451.         case mediumItem:    gSnowSpeed=0x02;    GetRidOfSnowflake(theData);    break;
  452.         case fastItem:        gSnowSpeed=0x03;    GetRidOfSnowflake(theData);    break;
  453.         case redItem:        gSnowColor=0x01;    break;
  454.         case greenItem:        gSnowColor=0x02;    break;
  455.         case blueItem:        gSnowColor=0x03;    break;
  456.         case cyanItem:        gSnowColor=0x04;    break;
  457.         case magentaItem:    gSnowColor=0x05;    break;
  458.         case yellowItem:    gSnowColor=0x06;    break;
  459.         case whiteItem:        gSnowColor=0x07;    break;
  460.         case mutateItem:    gSnowMutates^=0xFF;    break;
  461.     }
  462. }
  463.  
  464. void HandleHelpMenu(void)
  465. {
  466.     OpenTheWindow(kHelp);
  467. }
  468.